home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / language / embedded / ibm / sym_r3.arc / INSTR2.C < prev    next >
C/C++ Source or Header  |  1991-11-27  |  16KB  |  738 lines
  1. /******
  2.     Program: 68705R3 simulator
  3.     File: INSTR2.C
  4.     Notes: This file contiains the code for individual 6805 instructions.
  5.         It uses routines in INSTR.C
  6. ******/
  7.  
  8. #include "sim.h"
  9.  
  10. #ifdef MSC
  11. #include <graph.h>
  12. #endif
  13.  
  14. #define RW_A -1
  15. #define RW_X -2
  16. #define RW_SP -3
  17.  
  18. /************************************************************************/
  19. /* Routines to set condition code register bits for numeric op result   */
  20.  
  21. int ccr_c( value)
  22. int value;
  23. {
  24.     if (value < 0)
  25.     {
  26.     value += 256;
  27.     pgm_model.ccr |= CC_C;
  28.     }
  29.     else if (value > 255)
  30.     {
  31.     value -= 256;
  32.     pgm_model.ccr |= CC_C;
  33.     }
  34.     else
  35.     pgm_model.ccr &= ~CC_C;
  36.     return( value);
  37. }
  38.  
  39. int ccr_z( value)
  40. int value;
  41. {
  42.     if (value == 0)
  43.     pgm_model.ccr |= CC_Z;
  44.     else
  45.     pgm_model.ccr &= ~CC_Z;
  46.     return( value);
  47. }
  48.  
  49. int ccr_n( value)
  50. int value;
  51. {
  52.     if (value & 0x80)
  53.     pgm_model.ccr |= CC_N;
  54.     else
  55.     pgm_model.ccr &= ~CC_N;
  56.     return( value);
  57. }
  58. /************************************************************************/
  59. int std_ccr(value)
  60. int value;
  61. /* Set C, Z and N bits in ccr based on value */
  62. /* This is appropriate for SUB, CMP, SBC, CPX etc numeric instructions */
  63. {
  64.     value = ccr_c( value);
  65.     value = ccr_z( value);
  66.     value = ccr_n( value);
  67. }
  68. /************************************************************************/
  69.  
  70. sub( mode)
  71. int mode;
  72. {
  73.     int addr, data;
  74.  
  75.     addr = get_ea( mode);
  76.     data = sim_read( addr);
  77.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  78.     pgm_model.a -= data;
  79.     pgm_model.a = std_ccr( pgm_model.a);
  80.     append_rw( 0, RW_A, pgm_model.a);
  81. }
  82.  
  83. cmp( mode)
  84. int mode;
  85. {
  86.     int addr, data, result;
  87.  
  88.     addr = get_ea( mode);
  89.     data = sim_read( addr);
  90.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  91.     result = pgm_model.a - data;
  92.     result = std_ccr( result);
  93. }
  94.  
  95. sbc( mode)
  96. int mode;
  97. {
  98.     int addr, data;
  99.  
  100.     addr = get_ea( mode);
  101.     data = sim_read( addr);
  102.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  103.     pgm_model.a -= data;
  104.     if (pgm_model.ccr & CC_C)
  105.     pgm_model.a--;
  106.     pgm_model.a = std_ccr( pgm_model.a);
  107.     append_rw( 0, RW_A, pgm_model.a);
  108. }
  109.  
  110. cpx( mode)
  111. int mode;
  112. {
  113.     int addr, data, result;
  114.  
  115.     addr = get_ea( mode);
  116.     data = sim_read( addr);
  117.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  118.     result = pgm_model.x - data;
  119.     result = std_ccr( result);
  120. }
  121.  
  122. and( mode)
  123. int mode;
  124. {
  125.     int addr, data;
  126.  
  127.     addr = get_ea( mode);
  128.     data = sim_read( addr);
  129.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  130.     pgm_model.a &= data;
  131.     pgm_model.a = ccr_n( pgm_model.a);
  132.     pgm_model.a = ccr_z( pgm_model.a);
  133.     append_rw( 0, RW_A, pgm_model.a);
  134. }
  135.  
  136. bit( mode)
  137. int mode;
  138. {
  139.     int addr, data, result;
  140.  
  141.     addr = get_ea( mode);
  142.     data = sim_read( addr);
  143.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  144.     result = pgm_model.a & data;
  145.     result = ccr_n( result);
  146.     result = ccr_z( result);
  147. }
  148.  
  149. lda( mode)
  150. int mode;
  151. {
  152.     int addr, data;
  153.  
  154.     addr = get_ea( mode);
  155.     data = sim_read( addr);
  156.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  157.     pgm_model.a = data;
  158.     pgm_model.a = ccr_n( pgm_model.a);
  159.     pgm_model.a = ccr_z( pgm_model.a);
  160.     append_rw( 0, RW_A, pgm_model.a);
  161. }
  162.  
  163. sta( mode)
  164. int mode;
  165. /* Note: mode is never IMMEDIATE */
  166. {
  167.     int addr, data, temp;
  168.  
  169.     addr = get_ea( mode);
  170.     sim_write( addr, pgm_model.a);
  171.     append_rw( 0, addr, pgm_model.a);   /* 1 = Read, 0 = Write */
  172.     temp = ccr_n( pgm_model.a);
  173.     temp = ccr_z( pgm_model.a);
  174. }
  175.  
  176. eor( mode)
  177. int mode;
  178. {
  179.     int addr, data;
  180.  
  181.     addr = get_ea( mode);
  182.     data = sim_read( addr);
  183.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  184.     pgm_model.a ^= data;
  185.     pgm_model.a = ccr_n( pgm_model.a);
  186.     pgm_model.a = ccr_z( pgm_model.a);
  187.     append_rw( 0, RW_A, pgm_model.a);
  188. }
  189.  
  190. adc( mode)
  191. int mode;
  192. {
  193.     int addr, data, result;
  194.  
  195.     addr = get_ea( mode);
  196.     data = sim_read( addr);
  197.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  198.     result = pgm_model.a + data;
  199.     if (pgm_model.ccr & CC_C)
  200.     result++;
  201.     if (  ((pgm_model.a & 0x08) & (data & 0x08)) ||
  202.           ((data & 0x08) & (~result & 0x08)) ||
  203.           ((pgm_model.a & 0x08) & (~result & 0x08)) )
  204.     pgm_model.ccr |= CC_H;
  205.     else
  206.     pgm_model.ccr &= ~CC_H;
  207.     pgm_model.a = std_ccr( result);
  208.     append_rw( 0, RW_A, pgm_model.a);
  209. }
  210.  
  211. ora( mode)
  212. int mode;
  213. {
  214.     int addr, data;
  215.  
  216.     addr = get_ea( mode);
  217.     data = sim_read( addr);
  218.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  219.     pgm_model.a |= data;
  220.     pgm_model.a = ccr_n( pgm_model.a);
  221.     pgm_model.a = ccr_z( pgm_model.a);
  222.     append_rw( 0, RW_A, pgm_model.a);
  223. }
  224.  
  225. add( mode)
  226. int mode;
  227. {
  228.     int addr, data, result;
  229.  
  230.     addr = get_ea( mode);
  231.     data = sim_read( addr);
  232.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  233.     result = pgm_model.a + data;
  234.     if (  ((pgm_model.a & 0x08) & (data & 0x08)) ||
  235.           ((data & 0x08) & (~result & 0x08)) ||
  236.           ((pgm_model.a & 0x08) & (~result & 0x08)) )
  237.     pgm_model.ccr |= CC_H;
  238.     else
  239.     pgm_model.ccr &= ~CC_H;
  240.     pgm_model.a = std_ccr( result);
  241.     append_rw( 0, RW_A, pgm_model.a);
  242. }
  243.  
  244. jmp( mode)
  245. int mode;
  246. {
  247.     if (!disassemble)
  248.     pgm_model.pc = get_ea( mode);
  249.     /* condition codes are not affected */
  250. /*  symbol table addition */
  251.     append_rw( 1, pgm_model.pc, 0);
  252. }
  253.  
  254. jsr( mode)
  255. int mode;
  256. {
  257.     int addr;
  258.  
  259.     addr = get_ea( mode);
  260.     if (!disassemble)
  261.     {
  262.     push( pgm_model.pc & 0xFF);    /* PCL */
  263.     push(((pgm_model.pc & 0xF00) >> 8) | 0xF000);      /* PCH */
  264.     pgm_model.pc = addr;
  265. /*  symbol table addition */
  266.     append_rw( 1, pgm_model.pc, 0);
  267.  
  268.     }
  269. }
  270.  
  271. bsr( mode)
  272. int mode;  /* Must be REL */
  273. {
  274.     jsr( mode);    /* identical to JSR except for address mode, */
  275.                    /* which is handled by get_ea() */
  276. }
  277.  
  278. ldx( mode)
  279. int mode;
  280. {
  281.     int addr, data;
  282.  
  283.     addr = get_ea( mode);
  284.     data = sim_read( addr);
  285.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  286.     pgm_model.x = data;
  287.     data = ccr_n( data);
  288.     data = ccr_z( data);
  289. /* patch for x_reg */
  290.     append_rw( 0, RW_X, pgm_model.x);
  291.  
  292. }
  293.  
  294. stx( mode)
  295. {
  296.     int addr, data;
  297.  
  298.     addr = get_ea( mode);
  299.     sim_write( addr, pgm_model.x);
  300.     append_rw( 0, addr, pgm_model.x);   /* 1 = Read, 0 = Write */
  301.     data = pgm_model.x;
  302.     data = ccr_n( data);
  303.     data = ccr_z( data);
  304. }
  305.  
  306. bset( bit)
  307. int bit;
  308. {
  309.     int addr, data;
  310.  
  311.     addr = get_ea( DIRECT);
  312.     data = sim_bitread( addr, bit);  /* Returns byte value just like simread */
  313.                                      /* Bit is used to check bit in ports */
  314.                      /* See sim_mem.c */
  315.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  316.     data |= 1<<bit;
  317.     sim_write( addr, data);
  318.     append_rw( 0, addr, data);   /* 1 = Read, 0 = Write */
  319. }
  320.  
  321. bclr( bit)
  322. int bit;
  323. {
  324.     int addr, data;
  325.  
  326.     addr = get_ea( DIRECT);
  327.     data = sim_bitread( addr, bit);   /* See note above */
  328.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  329.     data &= ~(1<<bit);
  330.     sim_write( addr, data);
  331.     append_rw( 0, addr, data);   /* 1 = Read, 0 = Write */
  332. }
  333.  
  334. brset( bit)
  335. int bit;
  336. {
  337.     int addr, data;
  338.  
  339.     addr = get_ea( DIRECT);
  340.     data = sim_bitread( addr, bit);  /* Returns byte value just like simread */
  341.                                      /* Bit is used to check bit in ports */
  342.                      /* See sim_mem.c */
  343.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  344.     addr = get_ea( BTB);   /* Bit Test & Branch - branch rel */
  345.     if (data & (1 << bit))
  346.     {
  347.     if (!disassemble)
  348.         pgm_model.pc = addr;
  349.     pgm_model.ccr |= CC_C;
  350.     }
  351.     else
  352.     pgm_model.ccr &= ~CC_C;
  353. }
  354.  
  355. brclr( bit)
  356. int bit;
  357. {
  358.     int addr, data;
  359.  
  360.     addr = get_ea( DIRECT);
  361.     data = sim_bitread( addr, bit);       /* See note above */
  362.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  363.     addr = get_ea( BTB);   /* Bit Test & Branch - branch rel */
  364.     if (data & (1 << bit))
  365.     pgm_model.ccr |= CC_C;
  366.     else
  367.     {
  368.     if (!disassemble)
  369.         pgm_model.pc = addr;
  370.     pgm_model.ccr &= ~CC_C;
  371.     }
  372. }
  373.  
  374. branch( brtype)
  375. int brtype;
  376. {
  377.     int addr, brflag;
  378.  
  379.     addr = get_ea( REL);
  380.     switch (brtype)
  381.     {
  382.     case 0: /* BRA */
  383.     brflag = 1;
  384.     break;
  385.     case 1: /* BRN */
  386.     brflag = 0;
  387.     break;
  388.     case 2: /* BHI */
  389.     brflag= ((pgm_model.ccr & CC_C) == 0) && ((pgm_model.ccr & CC_Z) == 0);
  390.     break;
  391.     case 3: /* BLS */
  392.     brflag= ((pgm_model.ccr & CC_C) != 0) || ((pgm_model.ccr & CC_Z) != 0);
  393.     break;
  394.     case 4: /* BCC */
  395.     brflag = ((pgm_model.ccr & CC_C) == 0);
  396.     break;
  397.     case 5: /* BCS */
  398.     brflag = ((pgm_model.ccr & CC_C) != 0);
  399.     break;
  400.     case 6: /* BNE */
  401.     brflag = ((pgm_model.ccr & CC_Z) == 0);
  402.     break;
  403.     case 7: /* BEQ */
  404.     brflag = ((pgm_model.ccr & CC_Z) != 0);
  405.     break;
  406.     case 8: /* BHCC */
  407.     brflag = ((pgm_model.ccr & CC_H) == 0);
  408.     break;
  409.     case 9: /* BHCS */
  410.     brflag = ((pgm_model.ccr & CC_H) != 0);
  411.     break;
  412.     case 10: /* BPL */
  413.     brflag = ((pgm_model.ccr & CC_N) == 0);
  414.     break;
  415.     case 11: /* BMI */
  416.     brflag = ((pgm_model.ccr & CC_N) != 0);
  417.     break;
  418.     case 12: /* BMC */
  419.     brflag = ((pgm_model.ccr & CC_I) == 0);
  420.     break;
  421.     case 13: /* BMS */
  422.     brflag = ((pgm_model.ccr & CC_I) != 0);
  423.     break;
  424.     case 14: /* BIL */
  425.     brflag = external_intr;
  426.     break;
  427.     case 15: /* BIH */
  428.     brflag = !external_intr;
  429.     break;
  430.     default:
  431.     brflag = 0;
  432.     break;
  433.     }
  434.     if (brflag && !disassemble)
  435.     {
  436.     pgm_model.pc = addr;
  437. /*  symbol table addition */
  438.     append_rw( 1, pgm_model.pc, 0);
  439.     }
  440. }
  441.  
  442. neg( mode)
  443. int mode;
  444. {
  445.     int addr, data;
  446.  
  447.     addr = get_ea( mode);
  448.     data = sim_read( addr);
  449.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  450.     data = 0 - data;
  451.     data = std_ccr( data);    /* will get value in 0-255 and set C, N, Z */
  452.     sim_write( addr, data);
  453.     append_rw( 0, addr, data);   /* 1 = Read, 0 = Write */
  454. }
  455.  
  456. com( mode)
  457. int mode;
  458. {
  459.     int addr, data;
  460.  
  461.     addr = get_ea( mode);
  462.     data = sim_read( addr);
  463.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  464.     data ^= 0xFF;
  465.     data = ccr_n( data);
  466.     data = ccr_z( data);
  467.     pgm_model.ccr |= CC_C;      /* Carry always set */
  468.     sim_write( addr, data);
  469.     append_rw( 0, addr, data);   /* 1 = Read, 0 = Write */
  470. }
  471.  
  472. lsr( mode)
  473. int mode;
  474. {
  475.     int addr, data;
  476.  
  477.     addr = get_ea( mode);
  478.     data = sim_read( addr);
  479.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  480.     if (data & 0x01)
  481.         pgm_model.ccr |= CC_C;
  482.     else
  483.     pgm_model.ccr &= ~CC_C;
  484.     data >>= 1;
  485.     data = ccr_n( data);     /* N will always be 0 */
  486.     data = ccr_z( data);
  487.     sim_write( addr, data);
  488.     append_rw( 0, addr, data);   /* 1 = Read, 0 = Write */
  489. }
  490.  
  491. ror( mode)
  492. int mode;
  493. {
  494.     int addr, data, newdata;
  495.  
  496.     addr = get_ea( mode);
  497.     data = sim_read( addr);
  498.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  499. /* eliminate any "carries" from being shifted in */
  500.     newdata = (( data >>1) & 0x01FF);
  501.     if (pgm_model.ccr & CC_C)
  502.     newdata |= 0x80;
  503.     if (data & 0x01)
  504.         pgm_model.ccr |= CC_C;
  505.     else
  506.     pgm_model.ccr &= ~CC_C;
  507.     newdata = ccr_n( newdata);
  508.     newdata = ccr_z( newdata);
  509.     sim_write( addr, newdata);
  510.     append_rw( 0, addr, newdata);   /* 1 = Read, 0 = Write */
  511. }
  512.  
  513. asr( mode)
  514. int mode;
  515. {
  516.     int addr, data;
  517.  
  518.     addr = get_ea( mode);
  519.     data = sim_read( addr);
  520.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  521.     if (data & 0x01)
  522.         pgm_model.ccr |= CC_C;
  523.     else
  524.     pgm_model.ccr &= ~CC_C;
  525.     data >>= 1;
  526.     if (data & 0x40)
  527.     data |= 0x80;        /* hold bit 7 constant */
  528.     data = ccr_n( data);
  529.     data = ccr_z( data);
  530.     sim_write( addr, data);
  531.     append_rw( 0, addr, data);   /* 1 = Read, 0 = Write */
  532. }
  533.  
  534. lsl( mode)
  535. int mode;
  536. {
  537.     int addr, data;
  538.  
  539.     addr = get_ea( mode);
  540.     data = sim_read( addr);
  541.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  542.     data <<= 1;
  543.     data = std_ccr( data);       /* if b7 was on, C will be set and data */
  544.                                  /* corrected by subtracting 256 - perfect! */ 
  545.     sim_write( addr, data);
  546.     append_rw( 0, addr, data);   /* 1 = Read, 0 = Write */
  547. }
  548.  
  549. rol( mode)
  550. int mode;
  551. {
  552.     int addr, data, newdata;
  553.  
  554.     addr = get_ea( mode);
  555.     data = sim_read( addr);
  556.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  557. /* eliminate numbers in A and X register from increasing */
  558.     newdata = (( data <<1) & 0x01FF);
  559.     if (pgm_model.ccr & CC_C)
  560.     newdata |= 0x01;
  561.     if (data & 0x80)
  562.         pgm_model.ccr |= CC_C;
  563.     else
  564.     pgm_model.ccr &= ~CC_C;
  565.     newdata = ccr_n( newdata);
  566.     newdata = ccr_z( newdata);
  567.     sim_write( addr, newdata);
  568.     append_rw( 0, addr, newdata);   /* 1 = Read, 0 = Write */
  569. }
  570.  
  571. dec( mode)
  572. int mode;
  573. {
  574.     int addr, data;
  575.  
  576.     addr = get_ea( mode);
  577.     data = sim_read( addr);
  578.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  579.     data -= 1;
  580.     if (data < 0)
  581.     data = 255;
  582.     data = ccr_n( data);
  583.     data = ccr_z( data);
  584.     sim_write( addr, data);
  585.     append_rw( 0, addr, data);   /* 1 = Read, 0 = Write */
  586. }
  587.  
  588. inc( mode)
  589. int mode;
  590. {
  591.     int addr, data;
  592.  
  593.     addr = get_ea( mode);
  594.     data = sim_read( addr);
  595.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  596.     data += 1;
  597.     if (data >= 256)
  598.     data = 0;
  599.     data = ccr_n( data);
  600.     data = ccr_z( data);
  601.     sim_write( addr, data);
  602.     append_rw( 0, addr, data);   /* 1 = Read, 0 = Write */
  603. }
  604.  
  605. tst( mode)
  606. int mode;
  607. {
  608.     int addr, data;
  609.  
  610.     addr = get_ea( mode);
  611.     data = sim_read( addr);
  612.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  613.     /* No operation on data, or, if you prefer data = data - 0 */
  614.     data = ccr_n( data);
  615.     data = ccr_z( data);
  616. }
  617.  
  618. clr( mode)
  619. int mode;
  620. {
  621.     int addr, data;
  622.  
  623.     addr = get_ea( mode);
  624.     data = sim_read( addr);
  625.     append_rw( 1, addr, data);   /* 1 = Read, 0 = Write */
  626.     data = 0;
  627.     data = ccr_n( data);
  628.     data = ccr_z( data);
  629.     sim_write( addr, data);
  630.     append_rw( 0, addr, data);   /* 1 = Read, 0 = Write */
  631. }
  632.  
  633. swi(mode)
  634. int mode;
  635. {
  636.     rinterrupt( 0xFFC);    /* in instr.c */
  637. }
  638.  
  639. rts(mode)
  640. int mode;
  641. {
  642.     if (!disassemble)
  643.     {
  644.     pgm_model.pc = (( pull() & 0x0F ) << 8);
  645.     pgm_model.pc +=  pull();
  646.     }
  647. }
  648.  
  649. rti(mode)
  650. int mode;
  651. {
  652.     pgm_model.ccr = pull() & 0x1F;
  653.     pgm_model.a = pull();
  654.     pgm_model.x = pull();
  655.     rts( mode);
  656. }
  657.  
  658. tax( mode)
  659. int mode;
  660. {
  661.     pgm_model.x = ( 0x00FF & pgm_model.a );
  662.     append_rw( 0, RW_X, pgm_model.x);   /* 1 = Read, 0 = Write */
  663. }
  664.  
  665. txa( mode)
  666. int mode;
  667. {
  668.     pgm_model.a = ( 0x00FF & pgm_model.x );
  669.     append_rw( 0, RW_A, pgm_model.a);   /* 1 = Read, 0 = Write */
  670. }
  671.  
  672. clc( mode)
  673. int mode;
  674. {
  675.     pgm_model.ccr &= ~CC_C;
  676. }
  677.  
  678. sec( mode)
  679. int mode;
  680. {
  681.     pgm_model.ccr |= CC_C;
  682. }
  683.  
  684. cli( mode)
  685. int mode;
  686. {
  687.     pgm_model.ccr &= ~CC_I;
  688. }
  689.  
  690. sei( mode)
  691. int mode;
  692. {
  693.     pgm_model.ccr |= CC_I;
  694. }
  695.  
  696. nop( mode)
  697. int mode;
  698. {
  699.     /* no operation */
  700.     return( mode);
  701. }
  702.  
  703. rsp( mode)
  704. int mode;
  705. {
  706.     pgm_model.sp = 0x7F;
  707. }
  708.  
  709. mul( mode)
  710. int mode;
  711. {
  712.     int data;
  713.  
  714.     data = pgm_model.a * pgm_model.x;
  715.     pgm_model.a = data & 0x00ff;
  716.     pgm_model.x = (data >> 8) & 0x00ff;
  717.     append_rw( 0, RW_A, pgm_model.a);
  718.     append_rw( 0, RW_X, pgm_model.x);
  719.     pgm_model.ccr &= ~CC_C;
  720.     pgm_model.ccr &= ~CC_H;
  721.  
  722. }
  723.  
  724. stop( mode)
  725. int mode;
  726. {
  727.      pgm_model.ccr &= ~CC_I;
  728. }
  729.  
  730. wait( mode)
  731. int mode;
  732. {
  733.     pgm_model.ccr &= ~CC_I;
  734. }
  735.  
  736. /**************** end of file instr2.c **********************************/
  737.  
  738.